home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1996 February: Tool Chest / Apple Developer CD Series Tool Chest February 1996 (Apple Computer)(1996).iso / Tool Chest / Text / WASTE / WASTE 1.1.2 Distribution / Pseudo-UPI for THINK Pascal / LowMem.p < prev    next >
Encoding:
Text File  |  1995-10-12  |  33.5 KB  |  1,445 lines  |  [TEXT/PJMM]
  1. unit LowMem;
  2.  
  3. { Pascal Interface to the Macintosh Libraries }
  4.  
  5. { Copyright © Apple Computer Inc. }
  6. { All Rights Reserved }
  7.  
  8. { Adapted for use with THINK Pascal 4.0.x by Marco Piovanelli }
  9.  
  10. interface
  11.     uses
  12.         Types, Resources, Events, Windows;
  13.  
  14.     function LMGetScrVRes: SInt16;
  15.     inline
  16.         $3EB8, $0102;            { MOVE.W $0102,(SP) }
  17.  
  18.     procedure LMSetScrVRes (value: SInt16);
  19.     inline
  20.         $31DF, $0102;            { MOVE.W (SP)+,$0102 }
  21.  
  22.     function LMGetScrHRes: SInt16;
  23.     inline
  24.         $3EB8, $0104;            { MOVE.W $0104,(SP) }
  25.  
  26.     procedure LMSetScrHRes (value: SInt16);
  27.     inline
  28.         $31DF, $0104;            { MOVE.W (SP)+,$0104 }
  29.  
  30.     function LMGetMemTop: Ptr;
  31.     inline
  32.         $2EB8, $0108;            { MOVE.L $0108,(SP) }
  33.  
  34.     procedure LMSetMemTop (value: Ptr);
  35.     inline
  36.         $21DF, $0108;            { MOVE.L (SP)+,$0108 }
  37.  
  38.     function LMGetBufPtr: Ptr;
  39.     inline
  40.         $2EB8, $010C;            { MOVE.L $010C,(SP) }
  41.  
  42.     procedure LMSetBufPtr (value: Ptr);
  43.     inline
  44.         $21DF, $010C;            { MOVE.L (SP)+,$010C }
  45.  
  46.     function LMGetStackLowPoint: Ptr;
  47.     inline
  48.         $2EB8, $0110;            { MOVE.L $0110,(SP) }
  49.  
  50.     procedure LMSetStackLowPoint (value: Ptr);
  51.     inline
  52.         $21DF, $0110;            { MOVE.L (SP)+,$0110 }
  53.  
  54.     function LMGetHeapEnd: Ptr;
  55.     inline
  56.         $2EB8, $0114;            { MOVE.L $0114,(SP) }
  57.  
  58.     procedure LMSetHeapEnd (value: Ptr);
  59.     inline
  60.         $21DF, $0114;            { MOVE.L (SP)+,$0114 }
  61.  
  62.     function LMGetTheZone: THz;
  63.     inline
  64.         $2EB8, $0118;            { MOVE.L $0118,(SP) }
  65.  
  66.     procedure LMSetTheZone (value: THz);
  67.     inline
  68.         $21DF, $0118;            { MOVE.L (SP)+,$0118 }
  69.  
  70.     function LMGetUTableBase: Ptr;
  71.     inline
  72.         $2EB8, $011C;            { MOVE.L $011C,(SP) }
  73.  
  74.     procedure LMSetUTableBase (value: Ptr);
  75.     inline
  76.         $21DF, $011C;            { MOVE.L (SP)+,$011C }
  77.  
  78.     function LMGetCPUFlag: ByteParameter;
  79.     inline
  80.         $1EB8, $012F;            { MOVE.B $012F,(SP) }
  81.  
  82.     procedure LMSetCPUFlag (value: ByteParameter);
  83.     inline
  84.         $11DF, $012F;            { MOVE.B (SP)+,$012F }
  85.  
  86.     function LMGetApplLimit: Ptr;
  87.     inline
  88.         $2EB8, $0130;            { MOVE.L $0130,(SP) }
  89.  
  90.     procedure LMSetApplLimit (value: Ptr);
  91.     inline
  92.         $21DF, $0130;            { MOVE.L (SP)+,$0130 }
  93.  
  94.     function LMGetSysEvtMask: SInt16;
  95.     inline
  96.         $3EB8, $0144;            { MOVE.W $0144,(SP) }
  97.  
  98.     procedure LMSetSysEvtMask (value: SInt16);
  99.     inline
  100.         $31DF, $0144;            { MOVE.W (SP)+,$0144 }
  101.  
  102.     function LMGetRndSeed: SInt32;
  103.     inline
  104.         $2EB8, $0156;            { MOVE.L $0156,(SP) }
  105.  
  106.     procedure LMSetRndSeed (value: SInt32);
  107.     inline
  108.         $21DF, $0156;            { MOVE.L (SP)+,$0156 }
  109.  
  110.     function LMGetSEvtEnb: ByteParameter;
  111.     inline
  112.         $1EB8, $015C;            { MOVE.B $015C,(SP) }
  113.  
  114.     procedure LMSetSEvtEnb (value: ByteParameter);
  115.     inline
  116.         $11DF, $015C;            { MOVE.B (SP)+,$015C }
  117.  
  118.     function LMGetTicks: SInt32;
  119.     inline
  120.         $2EB8, $016A;            { MOVE.L $016A,(SP) }
  121.  
  122.     procedure LMSetTicks (value: SInt32);
  123.     inline
  124.         $21DF, $016A;            { MOVE.L (SP)+,$016A }
  125.  
  126.     function LMGetKeyThresh: SInt16;
  127.     inline
  128.         $3EB8, $018E;            { MOVE.W $018E,(SP) }
  129.  
  130.     procedure LMSetKeyThresh (value: SInt16);
  131.     inline
  132.         $31DF, $018E;            { MOVE.W (SP)+,$018E }
  133.  
  134.     function LMGetKeyRepThresh: SInt16;
  135.     inline
  136.         $3EB8, $0190;            { MOVE.W $0190,(SP) }
  137.  
  138.     procedure LMSetKeyRepThresh (value: SInt16);
  139.     inline
  140.         $31DF, $0190;            { MOVE.W (SP)+,$0190 }
  141.  
  142.     function LMGetUnitTableEntryCount: SInt16;
  143.     inline
  144.         $3EB8, $01D2;            { MOVE.W $01D2,(SP) }
  145.  
  146.     procedure LMSetUnitTableEntryCount (value: SInt16);
  147.     inline
  148.         $31DF, $01D2;            { MOVE.W (SP)+,$01D2 }
  149.  
  150.     function LMGetVIA: Ptr;
  151.     inline
  152.         $2EB8, $01D4;            { MOVE.L $01D4,(SP) }
  153.  
  154.     procedure LMSetVIA (value: Ptr);
  155.     inline
  156.         $21DF, $01D4;            { MOVE.L (SP)+,$01D4 }
  157.  
  158.     function LMGetSCCRd: Ptr;
  159.     inline
  160.         $2EB8, $01D8;            { MOVE.L $01D8,(SP) }
  161.  
  162.     procedure LMSetSCCRd (value: Ptr);
  163.     inline
  164.         $21DF, $01D8;            { MOVE.L (SP)+,$01D8 }
  165.  
  166.     function LMGetSCCWr: Ptr;
  167.     inline
  168.         $2EB8, $01DC;            { MOVE.L $01DC,(SP) }
  169.  
  170.     procedure LMSetSCCWr (value: Ptr);
  171.     inline
  172.         $21DF, $01DC;            { MOVE.L (SP)+,$01DC }
  173.  
  174.     function LMGetSPValid: ByteParameter;
  175.     inline
  176.         $1EB8, $01F8;            { MOVE.B $01F8,(SP) }
  177.  
  178.     procedure LMSetSPValid (value: ByteParameter);
  179.     inline
  180.         $11DF, $01F8;            { MOVE.B (SP)+,$01F8 }
  181.  
  182.     function LMGetSPATalkA: ByteParameter;
  183.     inline
  184.         $1EB8, $01F9;            { MOVE.B $01F9,(SP) }
  185.  
  186.     procedure LMSetSPATalkA (value: ByteParameter);
  187.     inline
  188.         $11DF, $01F9;            { MOVE.B (SP)+,$01F9 }
  189.  
  190.     function LMGetSPATalkB: ByteParameter;
  191.     inline
  192.         $1EB8, $01FA;            { MOVE.B $01FA,(SP) }
  193.  
  194.     procedure LMSetSPATalkB (value: ByteParameter);
  195.     inline
  196.         $11DF, $01FA;            { MOVE.B (SP)+,$01FA }
  197.  
  198.     function LMGetSPConfig: ByteParameter;
  199.     inline
  200.         $1EB8, $01FB;            { MOVE.B $01FB,(SP) }
  201.  
  202.     procedure LMSetSPConfig (value: ByteParameter);
  203.     inline
  204.         $11DF, $01FB;            { MOVE.B (SP)+,$01FB }
  205.  
  206.     function LMGetSPPortA: SInt16;
  207.     inline
  208.         $3EB8, $01FC;            { MOVE.W $01FC,(SP) }
  209.  
  210.     procedure LMSetSPPortA (value: SInt16);
  211.     inline
  212.         $31DF, $01FC;            { MOVE.W (SP)+,$01FC }
  213.  
  214.     function LMGetSPPortB: SInt16;
  215.     inline
  216.         $3EB8, $01FE;            { MOVE.W $01FE,(SP) }
  217.  
  218.     procedure LMSetSPPortB (value: SInt16);
  219.     inline
  220.         $31DF, $01FE;            { MOVE.W (SP)+,$01FE }
  221.  
  222.     function LMGetSPAlarm: SInt32;
  223.     inline
  224.         $2EB8, $0200;            { MOVE.L $0200,(SP) }
  225.  
  226.     procedure LMSetSPAlarm (value: SInt32);
  227.     inline
  228.         $21DF, $0200;            { MOVE.L (SP)+,$0200 }
  229.  
  230.     function LMGetSPFont: SInt16;
  231.     inline
  232.         $3EB8, $0204;            { MOVE.W $0204,(SP) }
  233.  
  234.     procedure LMSetSPFont (value: SInt16);
  235.     inline
  236.         $31DF, $0204;            { MOVE.W (SP)+,$0204 }
  237.  
  238.     function LMGetSPKbd: ByteParameter;
  239.     inline
  240.         $1EB8, $0206;            { MOVE.B $0206,(SP) }
  241.  
  242.     procedure LMSetSPKbd (value: ByteParameter);
  243.     inline
  244.         $11DF, $0206;            { MOVE.B (SP)+,$0206 }
  245.  
  246.     function LMGetSPPrint: ByteParameter;
  247.     inline
  248.         $1EB8, $0207;            { MOVE.B $0207,(SP) }
  249.  
  250.     procedure LMSetSPPrint (value: ByteParameter);
  251.     inline
  252.         $11DF, $0207;            { MOVE.B (SP)+,$0207 }
  253.  
  254.     function LMGetSPVolCtl: ByteParameter;
  255.     inline
  256.         $1EB8, $0208;            { MOVE.B $0208,(SP) }
  257.  
  258.     procedure LMSetSPVolCtl (value: ByteParameter);
  259.     inline
  260.         $11DF, $0208;            { MOVE.B (SP)+,$0208 }
  261.  
  262.     function LMGetSPClikCaret: ByteParameter;
  263.     inline
  264.         $1EB8, $0209;            { MOVE.B $0209,(SP) }
  265.  
  266.     procedure LMSetSPClikCaret (value: ByteParameter);
  267.     inline
  268.         $11DF, $0209;            { MOVE.B (SP)+,$0209 }
  269.  
  270.     function LMGetSPMisc2: ByteParameter;
  271.     inline
  272.         $1EB8, $020B;            { MOVE.B $020B,(SP) }
  273.  
  274.     procedure LMSetSPMisc2 (value: ByteParameter);
  275.     inline
  276.         $11DF, $020B;            { MOVE.B (SP)+,$020B }
  277.  
  278.     function LMGetTime: SInt32;
  279.     inline
  280.         $2EB8, $020C;            { MOVE.L $020C,(SP) }
  281.  
  282.     procedure LMSetTime (value: SInt32);
  283.     inline
  284.         $21DF, $020C;            { MOVE.L (SP)+,$020C }
  285.  
  286.     function LMGetBootDrive: SInt16;
  287.     inline
  288.         $3EB8, $0210;            { MOVE.W $0210,(SP) }
  289.  
  290.     procedure LMSetBootDrive (value: SInt16);
  291.     inline
  292.         $31DF, $0210;            { MOVE.W (SP)+,$0210 }
  293.  
  294.     function LMGetSFSaveDisk: SInt16;
  295.     inline
  296.         $3EB8, $0214;            { MOVE.W $0214,(SP) }
  297.  
  298.     procedure LMSetSFSaveDisk (value: SInt16);
  299.     inline
  300.         $31DF, $0214;            { MOVE.W (SP)+,$0214 }
  301.  
  302.     function LMGetKbdLast: ByteParameter;
  303.     inline
  304.         $1EB8, $0218;            { MOVE.B $0218,(SP) }
  305.  
  306.     procedure LMSetKbdLast (value: ByteParameter);
  307.     inline
  308.         $11DF, $0218;            { MOVE.B (SP)+,$0218 }
  309.  
  310.     function LMGetKbdType: ByteParameter;
  311.     inline
  312.         $1EB8, $021E;            { MOVE.B $021E,(SP) }
  313.  
  314.     procedure LMSetKbdType (value: ByteParameter);
  315.     inline
  316.         $11DF, $021E;            { MOVE.B (SP)+,$021E }
  317.  
  318.     function LMGetMemErr: SInt16;
  319.     inline
  320.         $3EB8, $0220;            { MOVE.W $0220,(SP) }
  321.  
  322.     procedure LMSetMemErr (value: SInt16);
  323.     inline
  324.         $31DF, $0220;            { MOVE.W (SP)+,$0220 }
  325.  
  326.     function LMGetSdVolume: ByteParameter;
  327.     inline
  328.         $1EB8, $0260;            { MOVE.B $0260,(SP) }
  329.  
  330.     procedure LMSetSdVolume (value: ByteParameter);
  331.     inline
  332.         $11DF, $0260;            { MOVE.B (SP)+,$0260 }
  333.  
  334.     function LMGetSoundPtr: Ptr;
  335.     inline
  336.         $2EB8, $0262;            { MOVE.L $0262,(SP) }
  337.  
  338.     procedure LMSetSoundPtr (value: Ptr);
  339.     inline
  340.         $21DF, $0262;            { MOVE.L (SP)+,$0262 }
  341.  
  342.     function LMGetSoundBase: Ptr;
  343.     inline
  344.         $2EB8, $0266;            { MOVE.L $0266,(SP) }
  345.  
  346.     procedure LMSetSoundBase (value: Ptr);
  347.     inline
  348.         $21DF, $0266;            { MOVE.L (SP)+,$0266 }
  349.  
  350.     function LMGetSoundLevel: ByteParameter;
  351.     inline
  352.         $1EB8, $027F;            { MOVE.B $027F,(SP) }
  353.  
  354.     procedure LMSetSoundLevel (value: ByteParameter);
  355.     inline
  356.         $11DF, $027F;            { MOVE.B (SP)+,$027F }
  357.  
  358.     function LMGetCurPitch: SInt16;
  359.     inline
  360.         $3EB8, $0280;            { MOVE.W $0280,(SP) }
  361.  
  362.     procedure LMSetCurPitch (value: SInt16);
  363.     inline
  364.         $31DF, $0280;            { MOVE.W (SP)+,$0280 }
  365.  
  366.     function LMGetROM85: SInt16;
  367.     inline
  368.         $3EB8, $028E;            { MOVE.W $028E,(SP) }
  369.  
  370.     procedure LMSetROM85 (value: SInt16);
  371.     inline
  372.         $31DF, $028E;            { MOVE.W (SP)+,$028E }
  373.  
  374.     function LMGetPortBUse: ByteParameter;
  375.     inline
  376.         $1EB8, $0291;            { MOVE.B $0291,(SP) }
  377.  
  378.     procedure LMSetPortBUse (value: ByteParameter);
  379.     inline
  380.         $11DF, $0291;            { MOVE.B (SP)+,$0291 }
  381.  
  382.     function LMGetGNEFilter: GNEFilterUPP;
  383.     inline
  384.         $2EB8, $029A;            { MOVE.L $029A,(SP) }
  385.  
  386.     procedure LMSetGNEFilter (value: GNEFilterUPP);
  387.     inline
  388.         $21DF, $029A;            { MOVE.L (SP)+,$029A }
  389.  
  390.     function LMGetSysZone: THz;
  391.     inline
  392.         $2EB8, $02A6;            { MOVE.L $02A6,(SP) }
  393.  
  394.     procedure LMSetSysZone (value: THz);
  395.     inline
  396.         $21DF, $02A6;            { MOVE.L (SP)+,$02A6 }
  397.  
  398.     function LMGetApplZone: THz;
  399.     inline
  400.         $2EB8, $02AA;            { MOVE.L $02AA,(SP) }
  401.  
  402.     procedure LMSetApplZone (value: THz);
  403.     inline
  404.         $21DF, $02AA;            { MOVE.L (SP)+,$02AA }
  405.  
  406.     function LMGetROMBase: Ptr;
  407.     inline
  408.         $2EB8, $02AE;            { MOVE.L $02AE,(SP) }
  409.  
  410.     procedure LMSetROMBase (value: Ptr);
  411.     inline
  412.         $21DF, $02AE;            { MOVE.L (SP)+,$02AE }
  413.  
  414.     function LMGetRAMBase: Ptr;
  415.     inline
  416.         $2EB8, $02B2;            { MOVE.L $02B2,(SP) }
  417.  
  418.     procedure LMSetRAMBase (value: Ptr);
  419.     inline
  420.         $21DF, $02B2;            { MOVE.L (SP)+,$02B2 }
  421.  
  422.     function LMGetDSAlertTab: Ptr;
  423.     inline
  424.         $2EB8, $02BA;            { MOVE.L $02BA,(SP) }
  425.  
  426.     procedure LMSetDSAlertTab (value: Ptr);
  427.     inline
  428.         $21DF, $02BA;            { MOVE.L (SP)+,$02BA }
  429.  
  430.     function LMGetDoubleTime: SInt32;
  431.     inline
  432.         $2EB8, $02F0;            { MOVE.L $02F0,(SP) }
  433.  
  434.     procedure LMSetDoubleTime (value: SInt32);
  435.     inline
  436.         $21DF, $02F0;            { MOVE.L (SP)+,$02F0 }
  437.  
  438.     function LMGetCaretTime: SInt32;
  439.     inline
  440.         $2EB8, $02F4;            { MOVE.L $02F4,(SP) }
  441.  
  442.     procedure LMSetCaretTime (value: SInt32);
  443.     inline
  444.         $21DF, $02F4;            { MOVE.L (SP)+,$02F4 }
  445.  
  446.     function LMGetScrDmpEnb: ByteParameter;
  447.     inline
  448.         $1EB8, $02F8;            { MOVE.B $02F8,(SP) }
  449.  
  450.     procedure LMSetScrDmpEnb (value: ByteParameter);
  451.     inline
  452.         $11DF, $02F8;            { MOVE.B (SP)+,$02F8 }
  453.  
  454.     function LMGetBufTgFNum: SInt32;
  455.     inline
  456.         $2EB8, $02FC;            { MOVE.L $02FC,(SP) }
  457.  
  458.     procedure LMSetBufTgFNum (value: SInt32);
  459.     inline
  460.         $21DF, $02FC;            { MOVE.L (SP)+,$02FC }
  461.  
  462.     function LMGetBufTgFFlg: SInt16;
  463.     inline
  464.         $3EB8, $0300;            { MOVE.W $0300,(SP) }
  465.  
  466.     procedure LMSetBufTgFFlg (value: SInt16);
  467.     inline
  468.         $31DF, $0300;            { MOVE.W (SP)+,$0300 }
  469.  
  470.     function LMGetBufTgFBkNum: SInt16;
  471.     inline
  472.         $3EB8, $0302;            { MOVE.W $0302,(SP) }
  473.  
  474.     procedure LMSetBufTgFBkNum (value: SInt16);
  475.     inline
  476.         $31DF, $0302;            { MOVE.W (SP)+,$0302 }
  477.  
  478.     function LMGetBufTgDate: SInt32;
  479.     inline
  480.         $2EB8, $0304;            { MOVE.L $0304,(SP) }
  481.  
  482.     procedure LMSetBufTgDate (value: SInt32);
  483.     inline
  484.         $21DF, $0304;            { MOVE.L (SP)+,$0304 }
  485.  
  486.     function LMGetLo3Bytes: SInt32;
  487.     inline
  488.         $2EB8, $031A;            { MOVE.L $031A,(SP) }
  489.  
  490.     procedure LMSetLo3Bytes (value: SInt32);
  491.     inline
  492.         $21DF, $031A;            { MOVE.L (SP)+,$031A }
  493.  
  494.     function LMGetMinStack: SInt32;
  495.     inline
  496.         $2EB8, $031E;            { MOVE.L $031E,(SP) }
  497.  
  498.     procedure LMSetMinStack (value: SInt32);
  499.     inline
  500.         $21DF, $031E;            { MOVE.L (SP)+,$031E }
  501.  
  502.     function LMGetDefltStack: SInt32;
  503.     inline
  504.         $2EB8, $0322;            { MOVE.L $0322,(SP) }
  505.  
  506.     procedure LMSetDefltStack (value: SInt32);
  507.     inline
  508.         $21DF, $0322;            { MOVE.L (SP)+,$0322 }
  509.  
  510.     function LMGetGZRootHnd: Handle;
  511.     inline
  512.         $2EB8, $0328;            { MOVE.L $0328,(SP) }
  513.  
  514.     procedure LMSetGZRootHnd (value: Handle);
  515.     inline
  516.         $21DF, $0328;            { MOVE.L (SP)+,$0328 }
  517.  
  518.     function LMGetGZMoveHnd: Handle;
  519.     inline
  520.         $2EB8, $0330;            { MOVE.L $0330,(SP) }
  521.  
  522.     procedure LMSetGZMoveHnd (value: Handle);
  523.     inline
  524.         $21DF, $0330;            { MOVE.L (SP)+,$0330 }
  525.  
  526.     function LMGetFCBSPtr: Ptr;
  527.     inline
  528.         $2EB8, $034E;            { MOVE.L $034E,(SP) }
  529.  
  530.     procedure LMSetFCBSPtr (value: Ptr);
  531.     inline
  532.         $21DF, $034E;            { MOVE.L (SP)+,$034E }
  533.  
  534.     function LMGetDefVCBPtr: Ptr;
  535.     inline
  536.         $2EB8, $0352;            { MOVE.L $0352,(SP) }
  537.  
  538.     procedure LMSetDefVCBPtr (value: Ptr);
  539.     inline
  540.         $21DF, $0352;            { MOVE.L (SP)+,$0352 }
  541.  
  542.     function LMGetCurDirStore: SInt32;
  543.     inline
  544.         $2EB8, $0398;            { MOVE.L $0398,(SP) }
  545.  
  546.     procedure LMSetCurDirStore (value: SInt32);
  547.     inline
  548.         $21DF, $0398;            { MOVE.L (SP)+,$0398 }
  549.  
  550.     function LMGetToExtFS: UniversalProcPtr;
  551.     inline
  552.         $2EB8, $03F2;            { MOVE.L $03F2,(SP) }
  553.  
  554.     procedure LMSetToExtFS (value: UniversalProcPtr);
  555.     inline
  556.         $21DF, $03F2;            { MOVE.L (SP)+,$03F2 }
  557.  
  558.     function LMGetFSFCBLen: SInt16;
  559.     inline
  560.         $3EB8, $03F6;            { MOVE.W $03F6,(SP) }
  561.  
  562.     procedure LMSetFSFCBLen (value: SInt16);
  563.     inline
  564.         $31DF, $03F6;            { MOVE.W (SP)+,$03F6 }
  565.  
  566.     function LMGetScrnBase: Ptr;
  567.     inline
  568.         $2EB8, $0824;            { MOVE.L $0824,(SP) }
  569.  
  570.     procedure LMSetScrnBase (value: Ptr);
  571.     inline
  572.         $21DF, $0824;            { MOVE.L (SP)+,$0824 }
  573.  
  574.     function LMGetMainDevice: GDHandle;
  575.     inline
  576.         $2EB8, $08A4;            { MOVE.L $08A4,(SP) }
  577.  
  578.     procedure LMSetMainDevice (value: GDHandle);
  579.     inline
  580.         $21DF, $08A4;            { MOVE.L (SP)+,$08A4 }
  581.  
  582.     function LMGetDeviceList: GDHandle;
  583.     inline
  584.         $2EB8, $08A8;            { MOVE.L $08A8,(SP) }
  585.  
  586.     procedure LMSetDeviceList (value: GDHandle);
  587.     inline
  588.         $21DF, $08A8;            { MOVE.L (SP)+,$08A8 }
  589.  
  590.     function LMGetQDColors: Handle;
  591.     inline
  592.         $2EB8, $08B0;            { MOVE.L $08B0,(SP) }
  593.  
  594.     procedure LMSetQDColors (value: Handle);
  595.     inline
  596.         $21DF, $08B0;            { MOVE.L (SP)+,$08B0 }
  597.  
  598.     function LMGetCrsrBusy: ByteParameter;
  599.     inline
  600.         $1EB8, $08CD;            { MOVE.B $08CD,(SP) }
  601.  
  602.     procedure LMSetCrsrBusy (value: ByteParameter);
  603.     inline
  604.         $11DF, $08CD;            { MOVE.B (SP)+,$08CD }
  605.  
  606.     function LMGetWidthListHand: Handle;
  607.     inline
  608.         $2EB8, $08E4;            { MOVE.L $08E4,(SP) }
  609.  
  610.     procedure LMSetWidthListHand (value: Handle);
  611.     inline
  612.         $21DF, $08E4;            { MOVE.L (SP)+,$08E4 }
  613.  
  614.     function LMGetJournalRef: SInt16;
  615.     inline
  616.         $3EB8, $08E8;            { MOVE.W $08E8,(SP) }
  617.  
  618.     procedure LMSetJournalRef (value: SInt16);
  619.     inline
  620.         $31DF, $08E8;            { MOVE.W (SP)+,$08E8 }
  621.  
  622.     function LMGetCrsrThresh: SInt16;
  623.     inline
  624.         $3EB8, $08EC;            { MOVE.W $08EC,(SP) }
  625.  
  626.     procedure LMSetCrsrThresh (value: SInt16);
  627.     inline
  628.         $31DF, $08EC;            { MOVE.W (SP)+,$08EC }
  629.  
  630.     function LMGetJFetch: UniversalProcPtr;
  631.     inline
  632.         $2EB8, $08F4;            { MOVE.L $08F4,(SP) }
  633.  
  634.     procedure LMSetJFetch (value: UniversalProcPtr);
  635.     inline
  636.         $21DF, $08F4;            { MOVE.L (SP)+,$08F4 }
  637.  
  638.     function LMGetJStash: UniversalProcPtr;
  639.     inline
  640.         $2EB8, $08F8;            { MOVE.L $08F8,(SP) }
  641.  
  642.     procedure LMSetJStash (value: UniversalProcPtr);
  643.     inline
  644.         $21DF, $08F8;            { MOVE.L (SP)+,$08F8 }
  645.  
  646.     function LMGetJIODone: UniversalProcPtr;
  647.     inline
  648.         $2EB8, $08FC;            { MOVE.L $08FC,(SP) }
  649.  
  650.     procedure LMSetJIODone (value: UniversalProcPtr);
  651.     inline
  652.         $21DF, $08FC;            { MOVE.L (SP)+,$08FC }
  653.  
  654.     function LMGetCurApRefNum: SInt16;
  655.     inline
  656.         $3EB8, $0900;            { MOVE.W $0900,(SP) }
  657.  
  658.     procedure LMSetCurApRefNum (value: SInt16);
  659.     inline
  660.         $31DF, $0900;            { MOVE.W (SP)+,$0900 }
  661.  
  662.     function LMGetCurrentA5: Ptr;
  663.     inline
  664.         $2EB8, $0904;            { MOVE.L $0904,(SP) }
  665.  
  666.     procedure LMSetCurrentA5 (value: Ptr);
  667.     inline
  668.         $21DF, $0904;            { MOVE.L (SP)+,$0904 }
  669.  
  670.     function LMGetCurStackBase: Ptr;
  671.     inline
  672.         $2EB8, $0908;            { MOVE.L $0908,(SP) }
  673.  
  674.     procedure LMSetCurStackBase (value: Ptr);
  675.     inline
  676.         $21DF, $0908;            { MOVE.L (SP)+,$0908 }
  677.  
  678.     function LMGetCurJTOffset: SInt16;
  679.     inline
  680.         $3EB8, $0934;            { MOVE.W $0934,(SP) }
  681.  
  682.     procedure LMSetCurJTOffset (value: SInt16);
  683.     inline
  684.         $31DF, $0934;            { MOVE.W (SP)+,$0934 }
  685.  
  686.     function LMGetCurPageOption: SInt16;
  687.     inline
  688.         $3EB8, $0936;            { MOVE.W $0936,(SP) }
  689.  
  690.     procedure LMSetCurPageOption (value: SInt16);
  691.     inline
  692.         $31DF, $0936;            { MOVE.W (SP)+,$0936 }
  693.  
  694.     function LMGetHiliteMode: ByteParameter;
  695.     inline
  696.         $1EB8, $0938;            { MOVE.B $0938,(SP) }
  697.  
  698.     procedure LMSetHiliteMode (value: ByteParameter);
  699.     inline
  700.         $11DF, $0938;            { MOVE.B (SP)+,$0938 }
  701.  
  702.     function LMGetPrintErr: SInt16;
  703.     inline
  704.         $3EB8, $0944;            { MOVE.W $0944,(SP) }
  705.  
  706.     procedure LMSetPrintErr (value: SInt16);
  707.     inline
  708.         $31DF, $0944;            { MOVE.W (SP)+,$0944 }
  709.  
  710.     function LMGetScrapSize: SInt32;
  711.     inline
  712.         $2EB8, $0960;            { MOVE.L $0960,(SP) }
  713.  
  714.     procedure LMSetScrapSize (value: SInt32);
  715.     inline
  716.         $21DF, $0960;            { MOVE.L (SP)+,$0960 }
  717.  
  718.     function LMGetScrapHandle: Handle;
  719.     inline
  720.         $2EB8, $0964;            { MOVE.L $0964,(SP) }
  721.  
  722.     procedure LMSetScrapHandle (value: Handle);
  723.     inline
  724.         $21DF, $0964;            { MOVE.L (SP)+,$0964 }
  725.  
  726.     function LMGetScrapCount: SInt16;
  727.     inline
  728.         $3EB8, $0968;            { MOVE.W $0968,(SP) }
  729.  
  730.     procedure LMSetScrapCount (value: SInt16);
  731.     inline
  732.         $31DF, $0968;            { MOVE.W (SP)+,$0968 }
  733.  
  734.     function LMGetScrapState: SInt16;
  735.     inline
  736.         $3EB8, $096A;            { MOVE.W $096A,(SP) }
  737.  
  738.     procedure LMSetScrapState (value: SInt16);
  739.     inline
  740.         $31DF, $096A;            { MOVE.W (SP)+,$096A }
  741.  
  742.     function LMGetScrapName: StringPtr;
  743.     inline
  744.         $2EB8, $096C;            { MOVE.L $096C,(SP) }
  745.  
  746.     procedure LMSetScrapName (value: StringPtr);
  747.     inline
  748.         $21DF, $096C;            { MOVE.L (SP)+,$096C }
  749.  
  750.     function LMGetROMFont0: Handle;
  751.     inline
  752.         $2EB8, $0980;            { MOVE.L $0980,(SP) }
  753.  
  754.     procedure LMSetROMFont0 (value: Handle);
  755.     inline
  756.         $21DF, $0980;            { MOVE.L (SP)+,$0980 }
  757.  
  758.     function LMGetApFontID: SInt16;
  759.     inline
  760.         $3EB8, $0984;            { MOVE.W $0984,(SP) }
  761.  
  762.     procedure LMSetApFontID (value: SInt16);
  763.     inline
  764.         $31DF, $0984;            { MOVE.W (SP)+,$0984 }
  765.  
  766.     function LMGetWindowList: WindowRef;
  767.     inline
  768.         $2EB8, $09D6;            { MOVE.L $09D6,(SP) }
  769.  
  770.     function LMGetSaveUpdate: SInt16;
  771.     inline
  772.         $3EB8, $09DA;            { MOVE.W $09DA,(SP) }
  773.  
  774.     procedure LMSetSaveUpdate (value: SInt16);
  775.     inline
  776.         $31DF, $09DA;            { MOVE.W (SP)+,$09DA }
  777.  
  778.     function LMGetPaintWhite: SInt16;
  779.     inline
  780.         $3EB8, $09DC;            { MOVE.W $09DC,(SP) }
  781.  
  782.     procedure LMSetPaintWhite (value: SInt16);
  783.     inline
  784.         $31DF, $09DC;            { MOVE.W (SP)+,$09DC }
  785.  
  786.     function LMGetWMgrPort: GrafPtr;
  787.     inline
  788.         $2EB8, $09DE;            { MOVE.L $09DE,(SP) }
  789.  
  790.     procedure LMSetWMgrPort (value: GrafPtr);
  791.     inline
  792.         $21DF, $09DE;            { MOVE.L (SP)+,$09DE }
  793.  
  794.     function LMGetGrayRgn: RgnHandle;
  795.     inline
  796.         $2EB8, $09EE;            { MOVE.L $09EE,(SP) }
  797.  
  798.     function LMGetDragHook: UniversalProcPtr;
  799.     inline
  800.         $2EB8, $09F6;            { MOVE.L $09F6,(SP) }
  801.  
  802.     procedure LMSetDragHook (value: UniversalProcPtr);
  803.     inline
  804.         $21DF, $09F6;            { MOVE.L (SP)+,$09F6 }
  805.  
  806. {}
  807. { To best work with future versions of the window manager,}
  808. { avoid using anything not defined with STRICT_WINDOWS}
  809. { set to true.  Most, if not all of these will still}
  810. { be supported in the next major version of the window manager}
  811. { but will trigger non-optimal compatibility code paths that}
  812. { should be avoided if possible.}
  813. {}
  814. {}
  815. { There is no reason to set the window list directly.}
  816. { Use BringToFront and SendBehind.}
  817. {}
  818. { If you need to do floating windows, avoid using GhostWindow }
  819. { and especially avoid patching the window manager.}
  820. {}
  821. { See Dean Yu's article in Develop 15 about how to implement floating}
  822. { windows using low-level window manager calls.  The next generation}
  823. { Macintosh Window Manager will have built-in support for floating}
  824. { and modal windows.}
  825. {}
  826.     procedure LMSetWindowList (value: WindowRef);
  827.     inline
  828.         $21DF, $09D6;            { MOVE.L (SP)+,$09D6 }
  829.  
  830.     function LMGetGhostWindow: WindowRef;
  831.     inline
  832.         $2EB8, $0A84;            { MOVE.L $0A84,(SP) }
  833.  
  834.     procedure LMSetGhostWindow (value: WindowRef);
  835.     inline
  836.         $21DF, $0A84;            { MOVE.L (SP)+,$0A84 }
  837.  
  838. {}
  839. { The auxiliary window record list will be empty in future}
  840. { versions of the window manager.  There is no reason to }
  841. { walk it or change it. }
  842. {}
  843.     function LMGetAuxWinHead: AuxWinHandle;
  844.     inline
  845.         $2EB8, $0CD0;            { MOVE.L $0CD0,(SP) }
  846.  
  847.     procedure LMSetAuxWinHead (value: AuxWinHandle);
  848.     inline
  849.         $21DF, $0CD0;            { MOVE.L (SP)+,$0CD0 }
  850.  
  851. {}
  852. { Please rely on the event manager to deliver activate and }
  853. { deactivate events and on the window manager to generate them.}
  854. {}
  855. { The next generation window manager will queue these events}
  856. { rather than just slamming these lowmems with the latest}
  857. { generated event, so it pays to rely on the event manager.}
  858. {}
  859.     function LMGetCurActivate: WindowRef;
  860.     inline
  861.         $2EB8, $0A64;            { MOVE.L $0A64,(SP) }
  862.  
  863.     procedure LMSetCurActivate (value: WindowRef);
  864.     inline
  865.         $21DF, $0A64;            { MOVE.L (SP)+,$0A64 }
  866.  
  867.     function LMGetCurDeactive: WindowRef;
  868.     inline
  869.         $2EB8, $0A68;            { MOVE.L $0A68,(SP) }
  870.  
  871.     procedure LMSetCurDeactive (value: WindowRef);
  872.     inline
  873.         $21DF, $0A68;            { MOVE.L (SP)+,$0A68 }
  874.  
  875.     function LMGetOldStructure: RgnHandle;
  876.     inline
  877.         $2EB8, $09E6;            { MOVE.L $09E6,(SP) }
  878.  
  879.     procedure LMSetOldStructure (value: RgnHandle);
  880.     inline
  881.         $21DF, $09E6;            { MOVE.L (SP)+,$09E6 }
  882.  
  883.     function LMGetOldContent: RgnHandle;
  884.     inline
  885.         $2EB8, $09EA;            { MOVE.L $09EA,(SP) }
  886.  
  887.     procedure LMSetOldContent (value: RgnHandle);
  888.     inline
  889.         $21DF, $09EA;            { MOVE.L (SP)+,$09EA }
  890.  
  891. {}
  892. { Please don't mess with the gray region.  There has}
  893. { to be a better way.  If not, please manipulate the}
  894. { existing region, don't change the value of the lowmem.}
  895. {}
  896.     procedure LMSetGrayRgn (value: RgnHandle);
  897.     inline
  898.         $21DF, $09EE;            { MOVE.L (SP)+,$09EE }
  899.  
  900.     function LMGetSaveVisRgn: RgnHandle;
  901.     inline
  902.         $2EB8, $09F2;            { MOVE.L $09F2,(SP) }
  903.  
  904.     procedure LMSetSaveVisRgn (value: RgnHandle);
  905.     inline
  906.         $21DF, $09F2;            { MOVE.L (SP)+,$09F2 }
  907.  
  908.     function LMGetOneOne: SInt32;
  909.     inline
  910.         $2EB8, $0A02;            { MOVE.L $0A02,(SP) }
  911.  
  912.     procedure LMSetOneOne (value: SInt32);
  913.     inline
  914.         $21DF, $0A02;            { MOVE.L (SP)+,$0A02 }
  915.  
  916.     function LMGetMinusOne: SInt32;
  917.     inline
  918.         $2EB8, $0A06;            { MOVE.L $0A06,(SP) }
  919.  
  920.     procedure LMSetMinusOne (value: SInt32);
  921.     inline
  922.         $21DF, $0A06;            { MOVE.L (SP)+,$0A06 }
  923.  
  924.     function LMGetTopMenuItem: SInt16;
  925.     inline
  926.         $3EB8, $0A0A;            { MOVE.W $0A0A,(SP) }
  927.  
  928.     procedure LMSetTopMenuItem (value: SInt16);
  929.     inline
  930.         $31DF, $0A0A;            { MOVE.W (SP)+,$0A0A }
  931.  
  932.     function LMGetAtMenuBottom: SInt16;
  933.     inline
  934.         $3EB8, $0A0C;            { MOVE.W $0A0C,(SP) }
  935.  
  936.     procedure LMSetAtMenuBottom (value: SInt16);
  937.     inline
  938.         $31DF, $0A0C;            { MOVE.W (SP)+,$0A0C }
  939.  
  940.     function LMGetMenuList: Handle;
  941.     inline
  942.         $2EB8, $0A1C;            { MOVE.L $0A1C,(SP) }
  943.  
  944.     procedure LMSetMenuList (value: Handle);
  945.     inline
  946.         $21DF, $0A1C;            { MOVE.L (SP)+,$0A1C }
  947.  
  948.     function LMGetMBarEnable: SInt16;
  949.     inline
  950.         $3EB8, $0A20;            { MOVE.W $0A20,(SP) }
  951.  
  952.     procedure LMSetMBarEnable (value: SInt16);
  953.     inline
  954.         $31DF, $0A20;            { MOVE.W (SP)+,$0A20 }
  955.  
  956.     function LMGetMenuFlash: SInt16;
  957.     inline
  958.         $3EB8, $0A24;            { MOVE.W $0A24,(SP) }
  959.  
  960.     procedure LMSetMenuFlash (value: SInt16);
  961.     inline
  962.         $31DF, $0A24;            { MOVE.W (SP)+,$0A24 }
  963.  
  964.     function LMGetTheMenu: SInt16;
  965.     inline
  966.         $3EB8, $0A26;            { MOVE.W $0A26,(SP) }
  967.  
  968.     procedure LMSetTheMenu (value: SInt16);
  969.     inline
  970.         $31DF, $0A26;            { MOVE.W (SP)+,$0A26 }
  971.  
  972.     function LMGetMBarHook: UniversalProcPtr;
  973.     inline
  974.         $2EB8, $0A2C;            { MOVE.L $0A2C,(SP) }
  975.  
  976.     procedure LMSetMBarHook (value: UniversalProcPtr);
  977.     inline
  978.         $21DF, $0A2C;            { MOVE.L (SP)+,$0A2C }
  979.  
  980.     function LMGetMenuHook: UniversalProcPtr;
  981.     inline
  982.         $2EB8, $0A30;            { MOVE.L $0A30,(SP) }
  983.  
  984.     procedure LMSetMenuHook (value: UniversalProcPtr);
  985.     inline
  986.         $21DF, $0A30;            { MOVE.L (SP)+,$0A30 }
  987.  
  988.     function LMGetTopMapHndl: Handle;
  989.     inline
  990.         $2EB8, $0A50;            { MOVE.L $0A50,(SP) }
  991.  
  992.     procedure LMSetTopMapHndl (value: Handle);
  993.     inline
  994.         $21DF, $0A50;            { MOVE.L (SP)+,$0A50 }
  995.  
  996.     function LMGetSysMapHndl: Handle;
  997.     inline
  998.         $2EB8, $0A54;            { MOVE.L $0A54,(SP) }
  999.  
  1000.     procedure LMSetSysMapHndl (value: Handle);
  1001.     inline
  1002.         $21DF, $0A54;            { MOVE.L (SP)+,$0A54 }
  1003.  
  1004.     function LMGetSysMap: SInt16;
  1005.     inline
  1006.         $3EB8, $0A58;            { MOVE.W $0A58,(SP) }
  1007.  
  1008.     procedure LMSetSysMap (value: SInt16);
  1009.     inline
  1010.         $31DF, $0A58;            { MOVE.W (SP)+,$0A58 }
  1011.  
  1012.     function LMGetCurMap: SInt16;
  1013.     inline
  1014.         $3EB8, $0A5A;            { MOVE.W $0A5A,(SP) }
  1015.  
  1016.     procedure LMSetCurMap (value: SInt16);
  1017.     inline
  1018.         $31DF, $0A5A;            { MOVE.W (SP)+,$0A5A }
  1019.  
  1020.     function LMGetResLoad: ByteParameter;
  1021.     inline
  1022.         $1EB8, $0A5E;            { MOVE.B $0A5E,(SP) }
  1023.  
  1024.     procedure LMSetResLoad (value: ByteParameter);
  1025.     inline
  1026.         $11DF, $0A5E;            { MOVE.B (SP)+,$0A5E }
  1027.  
  1028.     function LMGetResErr: SInt16;
  1029.     inline
  1030.         $3EB8, $0A60;            { MOVE.W $0A60,(SP) }
  1031.  
  1032.     procedure LMSetResErr (value: SInt16);
  1033.     inline
  1034.         $31DF, $0A60;            { MOVE.W (SP)+,$0A60 }
  1035.  
  1036.     function LMGetFScaleDisable: ByteParameter;
  1037.     inline
  1038.         $1EB8, $0A63;            { MOVE.B $0A63,(SP) }
  1039.  
  1040.     procedure LMSetFScaleDisable (value: ByteParameter);
  1041.     inline
  1042.         $11DF, $0A63;            { MOVE.B (SP)+,$0A63 }
  1043.  
  1044.     function LMGetDeskHook: UniversalProcPtr;
  1045.     inline
  1046.         $2EB8, $0A6C;            { MOVE.L $0A6C,(SP) }
  1047.  
  1048.     procedure LMSetDeskHook (value: UniversalProcPtr);
  1049.     inline
  1050.         $21DF, $0A6C;            { MOVE.L (SP)+,$0A6C }
  1051.  
  1052.     function LMGetTEDoText: UniversalProcPtr;
  1053.     inline
  1054.         $2EB8, $0A70;            { MOVE.L $0A70,(SP) }
  1055.  
  1056.     procedure LMSetTEDoText (value: UniversalProcPtr);
  1057.     inline
  1058.         $21DF, $0A70;            { MOVE.L (SP)+,$0A70 }
  1059.  
  1060.     function LMGetTERecal: UniversalProcPtr;
  1061.     inline
  1062.         $2EB8, $0A74;            { MOVE.L $0A74,(SP) }
  1063.  
  1064.     procedure LMSetTERecal (value: UniversalProcPtr);
  1065.     inline
  1066.         $21DF, $0A74;            { MOVE.L (SP)+,$0A74 }
  1067.  
  1068.     function LMGetResumeProc: UniversalProcPtr;
  1069.     inline
  1070.         $2EB8, $0A8C;            { MOVE.L $0A8C,(SP) }
  1071.  
  1072.     procedure LMSetResumeProc (value: UniversalProcPtr);
  1073.     inline
  1074.         $21DF, $0A8C;            { MOVE.L (SP)+,$0A8C }
  1075.  
  1076.     function LMGetANumber: SInt16;
  1077.     inline
  1078.         $3EB8, $0A98;            { MOVE.W $0A98,(SP) }
  1079.  
  1080.     procedure LMSetANumber (value: SInt16);
  1081.     inline
  1082.         $31DF, $0A98;            { MOVE.W (SP)+,$0A98 }
  1083.  
  1084.     function LMGetACount: SInt16;
  1085.     inline
  1086.         $3EB8, $0A9A;            { MOVE.W $0A9A,(SP) }
  1087.  
  1088.     procedure LMSetACount (value: SInt16);
  1089.     inline
  1090.         $31DF, $0A9A;            { MOVE.W (SP)+,$0A9A }
  1091.  
  1092.     function LMGetDABeeper: UniversalProcPtr;
  1093.     inline
  1094.         $2EB8, $0A9C;            { MOVE.L $0A9C,(SP) }
  1095.  
  1096.     procedure LMSetDABeeper (value: UniversalProcPtr);
  1097.     inline
  1098.         $21DF, $0A9C;            { MOVE.L (SP)+,$0A9C }
  1099.  
  1100.     function LMGetTEScrpLength: UInt16;
  1101.     inline
  1102.         $3EB8, $0AB0;            { MOVE.W $0AB0,(SP) }
  1103.  
  1104.     procedure LMSetTEScrpLength (value: UInt16);
  1105.     inline
  1106.         $31DF, $0AB0;            { MOVE.W (SP)+,$0AB0 }
  1107.  
  1108.     function LMGetTEScrpHandle: Handle;
  1109.     inline
  1110.         $2EB8, $0AB4;            { MOVE.L $0AB4,(SP) }
  1111.  
  1112.     procedure LMSetTEScrpHandle (value: Handle);
  1113.     inline
  1114.         $21DF, $0AB4;            { MOVE.L (SP)+,$0AB4 }
  1115.  
  1116.     function LMGetAppParmHandle: Handle;
  1117.     inline
  1118.         $2EB8, $0AEC;            { MOVE.L $0AEC,(SP) }
  1119.  
  1120.     procedure LMSetAppParmHandle (value: Handle);
  1121.     inline
  1122.         $21DF, $0AEC;            { MOVE.L (SP)+,$0AEC }
  1123.  
  1124.     function LMGetDSErrCode: SInt16;
  1125.     inline
  1126.         $3EB8, $0AF0;            { MOVE.W $0AF0,(SP) }
  1127.  
  1128.     procedure LMSetDSErrCode (value: SInt16);
  1129.     inline
  1130.         $31DF, $0AF0;            { MOVE.W (SP)+,$0AF0 }
  1131.  
  1132.     function LMGetResErrProc: ResErrUPP;
  1133.     inline
  1134.         $2EB8, $0AF2;            { MOVE.L $0AF2,(SP) }
  1135.  
  1136.     procedure LMSetResErrProc (value: ResErrUPP);
  1137.     inline
  1138.         $21DF, $0AF2;            { MOVE.L (SP)+,$0AF2 }
  1139.  
  1140.     function LMGetDlgFont: SInt16;
  1141.     inline
  1142.         $3EB8, $0AFA;            { MOVE.W $0AFA,(SP) }
  1143.  
  1144.     procedure LMSetDlgFont (value: SInt16);
  1145.     inline
  1146.         $31DF, $0AFA;            { MOVE.W (SP)+,$0AFA }
  1147.  
  1148.     function LMGetROMMapHandle: Handle;
  1149.     inline
  1150.         $2EB8, $0B06;            { MOVE.L $0B06,(SP) }
  1151.  
  1152.     procedure LMSetROMMapHandle (value: Handle);
  1153.     inline
  1154.         $21DF, $0B06;            { MOVE.L (SP)+,$0B06 }
  1155.  
  1156.     function LMGetWidthPtr: Ptr;
  1157.     inline
  1158.         $2EB8, $0B10;            { MOVE.L $0B10,(SP) }
  1159.  
  1160.     procedure LMSetWidthPtr (value: Ptr);
  1161.     inline
  1162.         $21DF, $0B10;            { MOVE.L (SP)+,$0B10 }
  1163.  
  1164.     function LMGetATalkHk2: Ptr;
  1165.     inline
  1166.         $2EB8, $0B18;            { MOVE.L $0B18,(SP) }
  1167.  
  1168.     procedure LMSetATalkHk2 (value: Ptr);
  1169.     inline
  1170.         $21DF, $0B18;            { MOVE.L (SP)+,$0B18 }
  1171.  
  1172.     function LMGetHWCfgFlags: SInt16;
  1173.     inline
  1174.         $3EB8, $0B22;            { MOVE.W $0B22,(SP) }
  1175.  
  1176.     procedure LMSetHWCfgFlags (value: SInt16);
  1177.     inline
  1178.         $31DF, $0B22;            { MOVE.W (SP)+,$0B22 }
  1179.  
  1180.     function LMGetWidthTabHandle: Handle;
  1181.     inline
  1182.         $2EB8, $0B2A;            { MOVE.L $0B2A,(SP) }
  1183.  
  1184.     procedure LMSetWidthTabHandle (value: Handle);
  1185.     inline
  1186.         $21DF, $0B2A;            { MOVE.L (SP)+,$0B2A }
  1187.  
  1188.     function LMGetLastSPExtra: SInt32;
  1189.     inline
  1190.         $2EB8, $0B4C;            { MOVE.L $0B4C,(SP) }
  1191.  
  1192.     procedure LMSetLastSPExtra (value: SInt32);
  1193.     inline
  1194.         $21DF, $0B4C;            { MOVE.L (SP)+,$0B4C }
  1195.  
  1196.     function LMGetMenuDisable: SInt32;
  1197.     inline
  1198.         $2EB8, $0B54;            { MOVE.L $0B54,(SP) }
  1199.  
  1200.     procedure LMSetMenuDisable (value: SInt32);
  1201.     inline
  1202.         $21DF, $0B54;            { MOVE.L (SP)+,$0B54 }
  1203.  
  1204.     function LMGetROMMapInsert: ByteParameter;
  1205.     inline
  1206.         $1EB8, $0B9E;            { MOVE.B $0B9E,(SP) }
  1207.  
  1208.     procedure LMSetROMMapInsert (value: ByteParameter);
  1209.     inline
  1210.         $11DF, $0B9E;            { MOVE.B (SP)+,$0B9E }
  1211.  
  1212.     function LMGetTmpResLoad: ByteParameter;
  1213.     inline
  1214.         $1EB8, $0B9F;            { MOVE.B $0B9F,(SP) }
  1215.  
  1216.     procedure LMSetTmpResLoad (value: ByteParameter);
  1217.     inline
  1218.         $11DF, $0B9F;            { MOVE.B (SP)+,$0B9F }
  1219.  
  1220.     function LMGetIntlSpec: Ptr;
  1221.     inline
  1222.         $2EB8, $0BA0;            { MOVE.L $0BA0,(SP) }
  1223.  
  1224.     procedure LMSetIntlSpec (value: Ptr);
  1225.     inline
  1226.         $21DF, $0BA0;            { MOVE.L (SP)+,$0BA0 }
  1227.  
  1228.     function LMGetWordRedraw: ByteParameter;
  1229.     inline
  1230.         $1EB8, $0BA5;            { MOVE.B $0BA5,(SP) }
  1231.  
  1232.     procedure LMSetWordRedraw (value: ByteParameter);
  1233.     inline
  1234.         $11DF, $0BA5;            { MOVE.B (SP)+,$0BA5 }
  1235.  
  1236.     function LMGetSysFontFam: SInt16;
  1237.     inline
  1238.         $3EB8, $0BA6;            { MOVE.W $0BA6,(SP) }
  1239.  
  1240.     procedure LMSetSysFontFam (value: SInt16);
  1241.     inline
  1242.         $31DF, $0BA6;            { MOVE.W (SP)+,$0BA6 }
  1243.  
  1244.     function LMGetSysFontSize: SInt16;
  1245.     inline
  1246.         $3EB8, $0BA8;            { MOVE.W $0BA8,(SP) }
  1247.  
  1248.     procedure LMSetSysFontSize (value: SInt16);
  1249.     inline
  1250.         $31DF, $0BA8;            { MOVE.W (SP)+,$0BA8 }
  1251.  
  1252.     function LMGetMBarHeight: SInt16;
  1253.     inline
  1254.         $3EB8, $0BAA;            { MOVE.W $0BAA,(SP) }
  1255.  
  1256.     procedure LMSetMBarHeight (value: SInt16);
  1257.     inline
  1258.         $31DF, $0BAA;            { MOVE.W (SP)+,$0BAA }
  1259.  
  1260.     function LMGetTESysJust: SInt16;
  1261.     inline
  1262.         $3EB8, $0BAC;            { MOVE.W $0BAC,(SP) }
  1263.  
  1264.     procedure LMSetTESysJust (value: SInt16);
  1265.     inline
  1266.         $31DF, $0BAC;            { MOVE.W (SP)+,$0BAC }
  1267.  
  1268.     function LMGetHighHeapMark: Ptr;
  1269.     inline
  1270.         $2EB8, $0BAE;            { MOVE.L $0BAE,(SP) }
  1271.  
  1272.     procedure LMSetHighHeapMark (value: Ptr);
  1273.     inline
  1274.         $21DF, $0BAE;            { MOVE.L (SP)+,$0BAE }
  1275.  
  1276.     function LMGetLastFOND: Handle;
  1277.     inline
  1278.         $2EB8, $0BC2;            { MOVE.L $0BC2,(SP) }
  1279.  
  1280.     procedure LMSetLastFOND (value: Handle);
  1281.     inline
  1282.         $21DF, $0BC2;            { MOVE.L (SP)+,$0BC2 }
  1283.  
  1284.     function LMGetFractEnable: ByteParameter;
  1285.     inline
  1286.         $1EB8, $0BF4;            { MOVE.B $0BF4,(SP) }
  1287.  
  1288.     procedure LMSetFractEnable (value: ByteParameter);
  1289.     inline
  1290.         $11DF, $0BF4;            { MOVE.B (SP)+,$0BF4 }
  1291.  
  1292.     function LMGetMMU32Bit: ByteParameter;
  1293.     inline
  1294.         $1EB8, $0CB2;            { MOVE.B $0CB2,(SP) }
  1295.  
  1296.     procedure LMSetMMU32Bit (value: ByteParameter);
  1297.     inline
  1298.         $11DF, $0CB2;            { MOVE.B (SP)+,$0CB2 }
  1299.  
  1300.     function LMGetTheGDevice: GDHandle;
  1301.     inline
  1302.         $2EB8, $0CC8;            { MOVE.L $0CC8,(SP) }
  1303.  
  1304.     procedure LMSetTheGDevice (value: GDHandle);
  1305.     inline
  1306.         $21DF, $0CC8;            { MOVE.L (SP)+,$0CC8 }
  1307.  
  1308.     function LMGetDeskCPat: PixPatHandle;
  1309.     inline
  1310.         $2EB8, $0CD8;            { MOVE.L $0CD8,(SP) }
  1311.  
  1312.     procedure LMSetDeskCPat (value: PixPatHandle);
  1313.     inline
  1314.         $21DF, $0CD8;            { MOVE.L (SP)+,$0CD8 }
  1315.  
  1316.     function LMGetTimeDBRA: SInt16;
  1317.     inline
  1318.         $3EB8, $0D00;            { MOVE.W $0D00,(SP) }
  1319.  
  1320.     procedure LMSetTimeDBRA (value: SInt16);
  1321.     inline
  1322.         $31DF, $0D00;            { MOVE.W (SP)+,$0D00 }
  1323.  
  1324.     function LMGetTimeSCCDB: SInt16;
  1325.     inline
  1326.         $3EB8, $0D02;            { MOVE.W $0D02,(SP) }
  1327.  
  1328.     procedure LMSetTimeSCCDB (value: SInt16);
  1329.     inline
  1330.         $31DF, $0D02;            { MOVE.W (SP)+,$0D02 }
  1331.  
  1332.     function LMGetJVBLTask: UniversalProcPtr;
  1333.     inline
  1334.         $2EB8, $0D28;            { MOVE.L $0D28,(SP) }
  1335.  
  1336.     procedure LMSetJVBLTask (value: UniversalProcPtr);
  1337.     inline
  1338.         $21DF, $0D28;            { MOVE.L (SP)+,$0D28 }
  1339.  
  1340.     function LMGetSynListHandle: Handle;
  1341.     inline
  1342.         $2EB8, $0D32;            { MOVE.L $0D32,(SP) }
  1343.  
  1344.     procedure LMSetSynListHandle (value: Handle);
  1345.     inline
  1346.         $21DF, $0D32;            { MOVE.L (SP)+,$0D32 }
  1347.  
  1348.     function LMGetMenuCInfo: MCTableHandle;
  1349.     inline
  1350.         $2EB8, $0D50;            { MOVE.L $0D50,(SP) }
  1351.  
  1352.     procedure LMSetMenuCInfo (value: MCTableHandle);
  1353.     inline
  1354.         $21DF, $0D50;            { MOVE.L (SP)+,$0D50 }
  1355.  
  1356.     function LMGetDTQueue: QHdrPtr;
  1357.     inline
  1358.         $2EB8, $0D92;            { MOVE.L $0D92,(SP) }
  1359.  
  1360.     procedure LMSetDTQueue (value: QHdrPtr);
  1361.     inline
  1362.         $21DF, $0D92;            { MOVE.L (SP)+,$0D92 }
  1363.  
  1364.     function LMGetJDTInstall: UniversalProcPtr;
  1365.     inline
  1366.         $2EB8, $0D9C;            { MOVE.L $0D9C,(SP) }
  1367.  
  1368.     procedure LMSetJDTInstall (value: UniversalProcPtr);
  1369.     inline
  1370.         $21DF, $0D9C;            { MOVE.L (SP)+,$0D9C }
  1371.  
  1372.     function LMGetTimeSCSIDB: SInt16;
  1373.     inline
  1374.         $3EB8, $0B24;            { MOVE.W $0B24,(SP) }
  1375.  
  1376.     procedure LMSetTimeSCSIDB (value: SInt16);
  1377.     inline
  1378.         $31DF, $0B24;            { MOVE.W (SP)+,$0B24 }
  1379.  
  1380.     function LMGetFSQHdr: QHdrPtr;
  1381.     inline
  1382.         $2EB8, $0360;            { MOVE.L $0360,(SP) }
  1383.  
  1384. {*************************************************************************************}
  1385. {}
  1386. {    MORE COMPLEX LOWMEM ACCESSORS}
  1387. {}
  1388. {*************************************************************************************}
  1389.     procedure LMGetDSAlertRect (var dsAlertRectValue: Rect);
  1390.     procedure LMSetDSAlertRect ({CONST}
  1391.                                     var dsAlertRectValue: Rect);
  1392.     procedure LMGetDragPattern (var dragPatternValue: Pattern);
  1393.     procedure LMSetDragPattern ({CONST}
  1394.                                     var dragPatternValue: Pattern);
  1395.     procedure LMGetDeskPattern (var deskPatternValue: Pattern);
  1396.     procedure LMSetDeskPattern ({CONST}
  1397.                                     var deskPatternValue: Pattern);
  1398.     procedure LMGetHiliteRGB (var hiliteRGBValue: RGBColor);
  1399.     procedure LMSetHiliteRGB ({CONST}
  1400.                                     var hiliteRGBValue: RGBColor);
  1401.     function LMGetEventQueue: QHdrPtr;
  1402.     procedure LMSetEventQueue (eventQueueValue: QHdrPtr);
  1403.     function LMGetVBLQueue: QHdrPtr;
  1404.     procedure LMSetVBLQueue (vblQueueValue: QHdrPtr);
  1405.     function LMGetDrvQHdr: QHdrPtr;
  1406.     procedure LMSetDrvQHdr (drvQHdrValue: QHdrPtr);
  1407.     function LMGetVCBQHdr: QHdrPtr;
  1408.     procedure LMSetVCBQHdr (vcbQHdrValue: QHdrPtr);
  1409. {*************************************************************************************}
  1410. {    "BLOCKMOVE ACCESSORS"}
  1411. {    }
  1412. {        These lowmem accessors use the BlockMove trap}
  1413. {*************************************************************************************}
  1414.     function LMGetCurApName: StringPtr;
  1415.     procedure LMSetCurApName (curApNameValue: ConstStr31Param);
  1416.     function LMGetSysResName: StringPtr;
  1417.     procedure LMSetSysResName (sysResNameValue: ConstStr15Param);
  1418.     function LMGetFinderName: StringPtr;
  1419.     procedure LMSetFinderName (finderNameValue: ConstStr15Param);
  1420.     function LMGetABusVars: Ptr;
  1421.     procedure LMSetABusVars (aBusVarsValue: Ptr);
  1422.     function LMGetScratch20: Ptr;
  1423.     procedure LMSetScratch20 (scratch20Value: univ Ptr);
  1424.     function LMGetToolScratch: Ptr;
  1425.     procedure LMSetToolScratch (toolScratchValue: univ Ptr);
  1426.     function LMGetApplScratch: Ptr;
  1427.     procedure LMSetApplScratch (applScratchValue: univ Ptr);
  1428. {*************************************************************************************}
  1429. {    "INDEXED ACCESSORS"}
  1430. {    }
  1431. {        These lowmem accessors take an index parameter to get/set an indexed}
  1432. {        lowmem global.}
  1433. {*************************************************************************************}
  1434.     function LMGetDAStrings (whichString: INTEGER): StringHandle;
  1435.     procedure LMSetDAStrings (DAStringsValue: StringHandle;
  1436.                                     whichString: INTEGER);
  1437.     function LMGetLvl2DT (vectorNumber: INTEGER): UniversalProcPtr;
  1438.     procedure LMSetLvl2DT (Lvl2DTValue: UniversalProcPtr;
  1439.                                     vectorNumber: INTEGER);
  1440.     function LMGetExtStsDT (vectorNumber: INTEGER): UniversalProcPtr;
  1441.     procedure LMSetExtStsDT (ExtStsDTValue: UniversalProcPtr;
  1442.                                     vectorNumber: INTEGER);
  1443.  
  1444. implementation
  1445. end.